home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / utilities / print / kprint.lha / KPrintV0.0.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-26  |  16.7 KB  |  427 lines
  1. /*
  2.  *   Projekt zum formatierten Drucken
  3.  *   unter Ausnutzung der Preferences-Struktur
  4.  *   und wahlweisen InLine-Optionen
  5.  */
  6.  
  7.  
  8. /************************************
  9. *                                   *
  10. * PreProc-Anweisungen               *
  11. * ===================               *
  12. *                                   *
  13. * Autor:    Datum:  Kommertar:      *
  14. * ------    ------  ----------      *
  15. * H.Kindler 23.7.91                 *
  16. *                                   *
  17. ************************************/
  18. #include <ctype.h>                  /* islower etc.  */
  19. #include <stdlib.h>                 /* exit etc.     */
  20. #include <stdio.h>                  /* printf etc.   */
  21. #include <string.h>                 /* strlen etc.   */
  22. #include <exec/types.h>             /* ULONG etc.    */
  23. #include <exec/memory.h>            /* AvailMem etc. */
  24. #include <intuition/intuition.h>    /* GetPrefs etc. */
  25. #include <sys/stat.h>               /* stat etc.     */
  26. #include <sys/time.h>               /* localtime etc.*/
  27.  
  28. #define DatumMax    25L                  /* Max. Stringlänge Datum        */
  29. #define ESC         \33                  /* Esacpe-Zeichen                */
  30. #define NUMLEN      6L                   /* Länge Zeilennummer (falls da) */
  31. #define PRINT       9L                   /* Lg 1.Teil PrtFile (prt:Print) */
  32. #define SIZE sizeof (struct Preferences) /* eine kleine Abkürzung         */
  33. #define SKIP        7L                   /* Zeilen am Seitenende          */
  34. #define TAB         8L                   /* Tabulatorgröße                */
  35.  
  36. void  Close_All    (void);                      /* Prototypen */
  37. void  InitPrinter  (void);                      /* der        */
  38. void  Open_All     (void);                      /* einzelnen  */
  39. void  PrintEscape  (void);                      /* Funktionen */
  40. short PrintKopf    (void);
  41. short PrintLine    (short lines, short pline);
  42. void  ResetPrinter (void);
  43.  
  44. short  CPL;                         /* Chars Per Line                  */
  45. char   Datum [DatumMax];            /* Datum-String                    */
  46. size_t DatumLen;                    /* Länge des Datum-Strings         */
  47. BOOL   DoNum = FALSE;               /* (Keine) Zeilennummer            */
  48. char   *FileName;                   /* Name, wie übergeben             */
  49. FILE   *FP;                         /* FilePointer Eingabe-File        */
  50. extern *IntuitionBase;              /* Intuition öffnen (DICE-Special) */
  51. short  LPP;                         /* Lines Per Page                  */
  52. short  LPI;                         /* Lines Per Inch                  */
  53. short  LLen;                        /* LineLength (ohne Ränder)        */
  54. BOOL   NoNum = FALSE;               /* ZN temporär unterdrücken (aus)  */
  55. short  NumLen = 0;                  /* Länge der ZeilenNummer (ZN)     */
  56. FILE   *PRT;                        /* FilePointer Drucker             */
  57. struct Preferences *PrefsBuffer;    /* Prefs-Struktur                  */
  58.  
  59.  
  60. /*******************************************
  61. *                                          *
  62. * Programm: Formatiertes Drucken von Files *
  63. * ======================================== *
  64. *                                          *
  65. * Autor:    Datum:  Kommertar:             *
  66. * ------    ------  ----------             *
  67. * H.Kindler 23.7.91                        *
  68. *                                          *
  69. *******************************************/
  70. void main (int argc, char **argv)
  71. {
  72.     short  c;                             /* var für fgetc              */
  73.     short  i;                             /* Zählvariable               */
  74.     short  anz   = 0;                     /* Zeichenzahl aktuelle Zeile */
  75.     short  lines = 1;                     /* Zeilenzahl                 */
  76.     short  pline = 0;                     /* Zeilen aktuelle Seite      */
  77.     struct stat statbuf;                  /* Infos übers File           */
  78.     time_t ftime;                         /* Datum des Files            */
  79.     struct tm *tp;                        /* Time-Struct von ftime      */
  80.     char   tmpnambuf [L_tmpnam];          /* Puffer PrtFile-tmpnam      */
  81.     char   *prtname = "prt:Print";        /* Name für PrtFile           */
  82.     char   prtfile [L_tmpnam + PRINT -2]; /* Fertiger Name              */
  83.  
  84.     FP = NULL;      /* File-Pointer auf NULL setzen (wird von */
  85.     PRT = NULL;     /* Close_All() zur Auswertung gebraucht)  */
  86.  
  87. /*
  88.  *    printf ("argc: %d\n",argc);
  89.  *    for (i = 0; i < argc; ++i)
  90.  *        printf ("argv[%d]: %s\n", i, argv[i]);
  91.  */
  92.     if ((argc < 2) ||                       /* eine kleine Hilfe */
  93.         ((argc == 2) && (*argv[1] == '?')))
  94.     {
  95.         printf ("\33[33mAufruf:\33[31m\t\%s PrintFile [NUM]\n\n", argv[0]);
  96.         puts ("Print druckt PrintFile (Wahlweise mit Zeilen-Nummerierung.)");
  97.         puts ("Es werden zur Seitenformatierung automatisch die Werte");
  98.         puts ("von Preferences benutzt.");
  99.         puts ("\nMomentan kann statt NUM als dritter Wert etwas beliebiges");
  100.         puts ("übergeben werden (\"Stinker\" tuts auch)!");
  101.         exit (RETURN_OK);
  102.     }
  103.     if (argc == 3)   /* Momentan tut alles! */
  104.     {
  105.         DoNum = TRUE;       /* Nummerierung einschalten  */
  106.         NumLen = NUMLEN;    /* Richtige Länge der Nummer */
  107.     }
  108.     Open_All ();
  109.     FileName = argv[1];
  110.     if (stat (FileName, &statbuf))          /* Infos übers File */
  111.     {
  112.         puts ("Error bei 'stat'");
  113.         Close_All ();
  114.         exit (RETURN_ERROR);
  115.     }
  116.     ftime = (time_t) statbuf.st_ctime;      /* Datum des Files */
  117.     tp = localtime (&ftime);                /* Aufbereiten     */
  118.     DatumLen = strftime (Datum, DatumMax, "%a %d.%b %Y  %H:%M:%S", tp);
  119. /*
  120.  *    printf ("Datum: %s\n Länge: %d\n", Datum, DatumLen);
  121.  */
  122.     if ((FP = fopen (FileName, "r")) == NULL)
  123.     {
  124.         printf ("Kann %s nicht öffnen!", argv[1]);
  125.         Close_All ();
  126.         exit (RETURN_ERROR);
  127.     }
  128.     strcpy (prtfile, prtname);              /* DruckName zusammenstellen */
  129.     tmpnam (tmpnambuf);
  130.     strcpy (prtfile + PRINT, tmpnambuf + 2);
  131.     if ((PRT = fopen (prtfile, "w")) == NULL)
  132.     {
  133.         puts ("Kann Drucker nicht ansprechen!");
  134.         Close_All ();
  135.         exit (RETURN_ERROR);
  136.     }
  137.     InitPrinter();
  138.     pline = LPP;                     /* Trick: Kopf 1.Seite und Anfang   */
  139.     pline = PrintLine(lines, pline); /* 1. Zeile werden korrekt gedruckt */
  140.     while ((c = fgetc (FP)) != EOF)
  141.     {
  142.         switch (c)
  143.         {
  144.             case '\n':                              /* NewLine           */
  145.                 lines++;                            /* neue Zeilennummer */
  146.                 pline = PrintLine (lines, pline);   /* neue Zeile        */
  147.                 anz = 0;                            /* ZeichenZähler = 0 */
  148.                 break;
  149.             case '\f':                              /* FormFeed          */
  150.                 pline = PrintKopf ();               /* neue Seite        */
  151.                 anz = 0;                            /* ZeichenZähler = 0 */
  152.                 break;
  153.             case '\t':                              /* Tabulator         */
  154.                 for (i = 0; i <= anz % TAB; i++)    /* Zeichen zum TAB   */
  155.                     fputc (' ', PRT);               /* mit ' ' füllen    */
  156.                 anz += anz % TAB;                   /* Zähler stellen    */
  157.                 break;
  158.             case '\33':             /* wird eigentlich nur gebraucht um  */
  159.                 fputc (c, PRT);     /* anz bei ESC-Sequencen nicht hoch- */
  160.                 PrintEscape ();     /* zuzählen (die Zeilen würden sonst */
  161.                 break;              /* zu kurz!)                         */
  162.             default:
  163.                 if (anz++ == CPL)                     /* Falls Zeilenende */
  164.                 {
  165.                     NoNum = TRUE;                     /* Zeilennummer aus */
  166.                     pline = PrintLine (lines, pline); /* neue Zeile       */
  167.                     NoNum = FALSE;                    /* Zeilennummer ein */
  168.                     anz = 0;                          /* ZeichenZähler =0 */
  169.                 }
  170.                 fputc (c, PRT);                    /* einfach nur drucken */
  171.         }
  172.     }
  173.     ResetPrinter ();
  174.     Close_All ();
  175.     exit (RETURN_OK);
  176. }
  177.  
  178.  
  179. /***********************************************
  180. *                                              *
  181. * Funktion: Alles Öffnen & Speicher            *
  182. * =================================            *
  183. *                                              *
  184. * Autor:    Datum:  Kommertar:                 *
  185. * ------    ------  ----------                 *
  186. * H.Kindler 23.7.91 Nur Puffer für Perferences *
  187. *                                              *
  188. *                                              *
  189. ***********************************************/
  190. void Open_All (void)
  191. {
  192.     UBYTE *AllocMem (ULONG size, ULONG requirements);
  193.  
  194.     PrefsBuffer = (struct Preferences *) AllocMem ((ULONG) SIZE, MEMF_CLEAR);     /*  Das gibt eine schöne, lange Zeile !!!!!! */
  195.     if (!PrefsBuffer)
  196.     {
  197.         puts ("Kein Speicher frei!");
  198.         Close_All ();
  199.         exit (RETURN_ERROR);
  200.     }
  201. }
  202.  
  203.  
  204. /***********************************************
  205. *                                              *
  206. * Funktion: Alles wieder schließen             *
  207. * ================================             *
  208. *                                              *
  209. * Autor:    Datum:  Kommertar:                 *
  210. * ------    ------  ----------                 *
  211. * H.Kindler 23.7.91 Preferences, File, Drucker *
  212. *                                              *
  213. ***********************************************/
  214. void Close_All (void)
  215. {
  216.     void FreeMem (ULONG *memory, ULONG size);
  217.  
  218.     if (PrefsBuffer) FreeMem ((ULONG *) PrefsBuffer, (ULONG) SIZE);
  219.     if (FP)  fclose (FP);
  220.     if (PRT) fclose (PRT);
  221. }
  222.  
  223.  
  224. /*******************************
  225. *                              *
  226. * Funktion: Kopf drucken       *
  227. * =====================        *
  228. *                              *
  229. * Autor:    Datum:  Kommentar: *
  230. * ------    ------  ---------- *
  231. * H.Kindler 24.7.91            *
  232. *                              *
  233. *******************************/
  234. short PrintKopf ()
  235. {
  236.     static short len;           /* Länge der Teile der Kopfzeile   */
  237.     static short fill;          /* das fehlt noch zur vollen Zeile */
  238.     static short filla;         /* zwischen Datum und FileName     */
  239.     static short fillb;         /* zwischen FileName und Seiten    */
  240.     static short page = 0;      /* Seitenzahl                      */
  241.     short i;                    /* Zähler                          */
  242.  
  243.     if (page)                                    /* Falls ! 1.Seite  */
  244.         fputc ('\f', PRT);                       /* FormFeed         */
  245.     else                                         /* sonst            */
  246.     {                                            /* SPACE berechnen  */
  247.         len = DatumLen + strlen (FileName) + 10; /*   Chars für Kopf */
  248.         fill = LLen - len;                       /*   restliche Char */
  249.         filla = fill / 2;                        /*   die Hälfte     */
  250.         fillb = fill - filla;                    /*   und der Rest   */
  251.     }
  252.     page++;                                      /* eine Seite mehr  */
  253.     fprintf (PRT, "%s", Datum);                  /* Datum            */
  254.     for ( i = 1; i <= filla; i++)                /* Zwischenraum     */
  255.         fputc (' ', PRT);
  256.     fprintf (PRT, "%s", FileName);               /* FileName         */
  257.     for ( i = 1; i <= fillb; i++)                /* Zwischenraum     */
  258.         fputc (' ', PRT);
  259.     fprintf (PRT, "Page: %4d\n\n\n", page);      /* Seitennummer     */
  260.     return (3);                                  /* so viele Zeilen  */
  261. }
  262.  
  263.  
  264. /***************************************
  265. *                                      *
  266. * Funktion: Zeilenvorschub drucken     *
  267. * ================================     *
  268. *                                      *
  269. * Autor:    Datum:  Kommentar:         *
  270. * ------    ------  ----------         *
  271. * H.Kindler 24.7.91 am Blattende: Kopf *
  272. *                                      *
  273. ***************************************/
  274. short PrintLine (short lines,      /*  Anzahl der '\n' im File         */
  275.                  short pline)      /*  Auf dieser Seite gedruckte '\n' */
  276. {
  277.     if (pline++ < LPP)                      /* Falls Seite nicht voll */
  278.         fputc ('\n', PRT);                  /* neue Zeile             */
  279.     else                                    /* sonst                  */
  280.         pline = PrintKopf ();               /* neue Seite             */
  281.     if (DoNum)                              /* Falls Zeilennummern    */
  282.         if (NoNum)                          /* Falls unterdrücken     */
  283.             fputs ("      ", PRT);          /* Space drucken          */
  284.         else                                /* sonst                  */
  285.             fprintf (PRT, "%04d: ", lines); /* Zeilennummer drucken   */
  286.     return (pline);                         /* so viele Zeilen        */
  287. }
  288.  
  289.  
  290. /*********************************
  291. *                                *
  292. * Funktion: ESC-Sequence drucken *
  293. * ============================== *
  294. *                                *
  295. * Autor:    Datum:  Kommentar:   *
  296. * ------    ------  ----------   *
  297. * H.Kindler 26.7.91              *
  298. *                                *
  299. *********************************/
  300. void PrintEscape (void)
  301. {
  302.     short c;
  303.  
  304.     c = fgetc (FP);           /* Ein Zeichen folgt immer */
  305.     fputc (c, PRT);
  306.     switch (c)
  307.     {
  308.         case '#':             /* hier folgt jeweils noch */
  309.         case '(':             /* ein Zeichen             */
  310.             c = fgetc (FP);
  311.             fputc (c, PRT);
  312.             break;
  313.         case '[':             /* begrenzt durch E,F,g,m,p,q,r,s,v,w,x,z */
  314.             while (!((islower (c = fgetc (FP)) || (c == 'E') || (c == 'F'))))
  315.             {
  316.                 fputc (c, PRT);
  317.             }
  318.             fputc (c, PRT);
  319.     }
  320.     return ();
  321. }
  322.  
  323.  
  324. /******************************************
  325. *                                         *
  326. * Funktion: Drucker vorbereiten           *
  327. * =============================           *
  328. *                                         *
  329. * Autor:    Datum:  Kommentar:            *
  330. * ------    ------  ----------            *
  331. * H.Kindler 25.7.91 Werte von Preferences *
  332. *                                         *
  333. ******************************************/
  334. void InitPrinter (void)
  335. {
  336.  
  337.     struct Preferences *GetPrefs (struct Preferences *preferences, short size);
  338.  
  339.     short  lm;           /* Left Margin  */
  340.     short  rm;           /* Right Margin */
  341.     short  ppl;          /* PaPerLength  */
  342.  
  343.     GetPrefs (PrefsBuffer, (short) SIZE);
  344.     switch (PrefsBuffer->PrintPitch)     /* Zeilenlänge festlegen */
  345.     {
  346.         case PICA:
  347.             LLen = 80;
  348.             break;
  349.         case ELITE:
  350.             LLen = 96;
  351.             break;
  352.         case FINE:
  353.             LLen = 136;
  354.             break;
  355.         default:
  356.             puts ("Hier läuft was falsch! (Schriftbreite)");
  357.             Close_All ();
  358.             exit (RETURN_WARN);
  359.     }
  360.     switch (PrefsBuffer->PrintSpacing)  /* Zeilen pro Zoll */
  361.     {
  362.         case SIX_LPI:
  363.             LPI = 6;
  364.             break;
  365.         case EIGHT_LPI:
  366.             LPI = 8;
  367.             break;
  368.         default:
  369.             puts ("Hier läuft was falsch! (Zeilenabstand)");
  370.             Close_All ();
  371.             exit (RETURN_WARN);
  372.     }
  373. /*
  374.  *    switch (PrefsBuffer->PaperSize)
  375.  *    {
  376.  *        case US_LETTER:
  377.  *            puts ("US_LETTER");
  378.  *            break;
  379.  *        case US_LEGAL:
  380.  *            puts ("US_LEGAL");
  381.  *            break;
  382.  *        case N_TRACTOR:
  383.  *            puts ("N_TRACTOR");
  384.  *            break;
  385.  *        case W_TRACTOR:
  386.  *            puts ("W_TRACTOR");
  387.  *            break;
  388.  *        case CUSTOM:
  389.  *            puts ("CUSTOM");
  390.  *            break;
  391.  *        default:
  392.  *            puts ("Hier läuft was falsch!");
  393.  *            Close_All ();
  394.  *            exit (RETURN_WARN);
  395.  *    }
  396.  */
  397.     ppl = PrefsBuffer->PaperLength;         /* Papierlänge       */
  398.     LPP = ppl - SKIP;                       /* so viel bedrucken */
  399.     lm = PrefsBuffer->PrintLeftMargin - 1;  /* Ränder            */
  400.     rm = PrefsBuffer->PrintRightMargin;
  401.     if (rm > LLen)
  402.         puts ("Achtung! Rechter Rand zu groß!!");
  403.     LLen = rm - lm;                         /* Platz zw. Rändern    */
  404.     CPL  = LLen - NumLen;                   /* weniger Nummernlänge */
  405.     fputs ("\33#1", PRT);          /* Drucker vom System initialisieren  */
  406.     fprintf(PRT, "\33[%dt", ppl);  /* Seitenlänge (System macht's nicht) */
  407.     return();
  408. }
  409.  
  410.  
  411. /********************************
  412. *                               *
  413. * Funktion: Drucker verlassen   *
  414. * ===========================   *
  415. *                               *
  416. * Autor:    Datum:  Kommentar:  *
  417. * ------    ------  ----------  *
  418. * H.Kindler 25.7.91             *
  419. *                               *
  420. ********************************/
  421. void ResetPrinter (void)
  422. {
  423.     fputs ("\f\33c", PRT);     /* FF, RESET */
  424.     return ();
  425. }
  426.  
  427.